#include "Decrypter.h"

char * Decrypter(mpz_t * cryptage, ClefPrivee * clef, int taille)
{
    int i;
    mpz_t u;
    mpz_t n;
    mpz_init_set(u, ClefPriveeGetu(clef));
    mpz_init_set(n, ClefPriveeGetn(clef));

    gmp_printf("voici la clef privée utilisée : (%Zd, %Zd) \n", u, n);

    char * resultat=NULL;
    resultat=(char *)malloc((taille+1)*sizeof(char));
    i=0;
    for (i=0; i<taille; i++)
    {
        mpz_t caractere;
        mpz_init(caractere);
        mpz_powm(caractere, cryptage[i], u, n);
//        gmp_printf("voici le code ascii du caractere %d : %Zd \n", i, caractere);
        /* On met modulo 256 pour tjs tomber sur un code ascii meme si l'utilisateur essaye de déchiffrer un message qui n'est pas pour lui */
//        resultat[i]=(char) mpz_get_ui(caractere);
        resultat[i]=mpz_mod_ui(caractere, caractere, (unsigned long int)256);
        gmp_printf("voici le code ascii du caractere %d : %Zd \n", i, caractere);
        mpz_clear(caractere);
    }
    resultat[taille]='\0';
    mpz_clear(u);
    mpz_clear(n);
    return resultat;
}

mpz_t *DecypterCharger(const char * nomfichier, int * taille)
{
    FILE* f;
    mpz_t * resultat;
    int i;

    f = fopen(nomfichier, "r");
    if (f==NULL)
    {
        printf("Erreur lors de l'ouverture de %s\n", nomfichier);
        return NULL;
    }

    assert( fscanf( f , "Texte Crypte: \n nbCaracteres: %d \n \n", taille) >=0);

//    printf("voici la taille du texte à decrypter : %d \n", (*taille));

    resultat=(mpz_t *)malloc((*taille)*sizeof(mpz_t));

    for(i=0; i< (*taille); i++)
    {
        mpz_init(resultat[i]);
        assert(gmp_fscanf(f, "%Zd \n", &resultat[i])>=0);
    }
    fclose(f);
    printf("Lecture du texte crypte: %s ...OK\n", nomfichier);
    return resultat;
}

//mpz_t * CryptageConvertir(char * cryptage)
//{
//    mpz_t * resultat;
//    int i;
//    resultat=(mpz_t *)malloc((strlen(cryptage))*sizeof(mpz_t));
//    i=0;
//    while(i<strlen(cryptage))
//    {
//        while(cryptage[i]!='\n')
//        {
//
//        }
//        mpz_init_set_str(resultat[i], );
//    }
//
//
//    return "text_crypte";
//}

void testRegressionDecrypter()
{
    mpz_t a;
    mpz_t b;
    mpz_t c;
    int taille;
    ClefPublique * clef;
    mpz_t * resultat;
    resultat=DecypterCharger("test_regression_crypter", &taille);
    ClefPubliqueInitialiser(&clef);
    mpz_init_set_ui(a, (unsigned long int)436);
    mpz_init_set_ui(b, (unsigned long int)53);
    mpz_init_set_ui(c, (unsigned long int)396);
    ClefPubliqueSetn(clef, a);
    ClefPubliqueSetc(clef, b);
    ClefPubliqueSetm(clef, c);
    ClefPrivee * clefprivee=ClefPriveeGenerer(clef);
    char *texte_decrypte = Decrypter(resultat, clefprivee , taille);
    printf("voici le texte décrypté : %s \n", texte_decrypte);
    ClefPriveeLiberer(clefprivee);
    ClefPubliqueLiberer(clef);
    CrypterLiberer(resultat, taille);
    free(texte_decrypte);

    mpz_clear(a);
    mpz_clear(b);
    mpz_clear(c);

}
